/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_conv2d_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/nested_pairs_to_triple.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/conv2d/selector_list.h"
#include "test/conv2d/window_stride_fixture.h"

#include <array>
#include <vector>

using DataTypeList = sycldnn::types::KernelDataTypes;
using Selectors = sycldnn::types::SelectorList;
using Backends = sycldnn::types::AllBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<Selectors, DataTypeList>::type;
using BackendTypePairs =
    sycldnn::types::CartesianProduct<SNNTypePairs, Backends>::type;
using TestTriples = sycldnn::types::NestedPairsToTriple<BackendTypePairs>::type;

using GTestTypeTriples = sycldnn::types::ToGTestTypes<TestTriples>::type;

template <typename Pair>
using InputBackpropWindow1Stride1 = WindowStrideTest<Pair, 1, 1>;
TYPED_TEST_SUITE(InputBackpropWindow1Stride1, GTestTypeTriples);
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 11., 17., 23.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 11., 17., 23.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 70., 110., 150.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 70., 110., 150.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 2., 4., 3., 6., 4., 8.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 2., 4., 3., 6., 4., 8.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 11., 11., 25., 17., 39., 23., 53.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 11., 11., 25., 17., 39., 23., 53.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  70.,  174.,
                                         110., 278., 150., 382.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  70.,  174.,
                                         110., 278., 150., 382.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  2., 4., 6.,  8.,
                                         3., 6., 9., 12., 4., 8., 12., 16.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  2., 4., 6.,  8.,
                                         3., 6., 9., 12., 4., 8., 12., 16.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 11., 25.,
                                         39., 53., 17., 39., 61., 83.,
                                         23., 53., 83., 113.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 11., 25.,
                                         39., 53., 17., 39., 61., 83.,
                                         23., 53., 83., 113.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 70.,  174.,
                                         278., 382., 110., 278., 446., 614.,
                                         150., 382., 614., 846.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 70.,  174.,
                                         278., 382., 110., 278., 446., 614.,
                                         150., 382., 614., 846.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 11., 17., 23., 29., 35.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 11., 17., 23., 29., 35.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 70., 110., 150., 190., 230.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 70., 110., 150., 190., 230.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 2., 4.,  3., 6.,
                                         4., 8., 5., 10., 6., 12.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 2., 4.,  3., 6.,
                                         4., 8., 5., 10., 6., 12.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 11., 25., 17., 39.,
                                         23., 53., 29., 67., 35., 81.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 11., 25., 17., 39.,
                                         23., 53., 29., 67., 35., 81.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  70.,  174., 110., 278.,
                                         150., 382., 190., 486., 230., 590.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  70.,  174., 110., 278.,
                                         150., 382., 190., 486., 230., 590.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11., 17., 23.,  11., 25., 39.,  53.,  17., 39., 61.,  83.,
      23., 53., 83., 113., 29., 67., 105., 143., 35., 81., 127., 173.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11., 17., 23.,  11., 25., 39.,  53.,  17., 39., 61.,  83.,
      23., 53., 83., 113., 29., 67., 105., 143., 35., 81., 127., 173.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,  110., 150., 70.,  174., 278., 382.,  110., 278., 446., 614.,
      150., 382., 614., 846., 190., 486., 782., 1078., 230., 590., 950., 1310.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,  110., 150., 70.,  174., 278., 382.,  110., 278., 446., 614.,
      150., 382., 614., 846., 190., 486., 782., 1078., 230., 590., 950., 1310.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 11., 17., 23., 29., 35., 41., 47.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 11., 17., 23., 29., 35., 41., 47.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150.,
                                         190., 230., 270., 310.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150.,
                                         190., 230., 270., 310.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2., 4.,  3., 6.,  4., 8.,
                                         5., 10., 6., 12., 7., 14., 8., 16.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2., 4.,  3., 6.,  4., 8.,
                                         5., 10., 6., 12., 7., 14., 8., 16.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 11., 25., 17., 39.,
                                         23., 53., 29., 67., 35., 81.,
                                         41., 95., 47., 109.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 11., 25., 17., 39.,
                                         23., 53., 29., 67., 35., 81.,
                                         41., 95., 47., 109.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  70.,  174., 110., 278.,
                                         150., 382., 190., 486., 230., 590.,
                                         270., 694., 310., 798.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  70.,  174., 110., 278.,
                                         150., 382., 190., 486., 230., 590.,
                                         270., 694., 310., 798.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.,
                                         7., 14., 21., 28., 8., 16., 24., 32.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.,
                                         7., 14., 21., 28., 8., 16., 24., 32.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17., 23., 11.,  25.,  39., 53.,  17.,  39., 61.,
      83.,  23.,  53., 83., 113., 29.,  67., 105., 143., 35., 81.,
      127., 173., 41., 95., 149., 203., 47., 109., 171., 233.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17., 23., 11.,  25.,  39., 53.,  17.,  39., 61.,
      83.,  23.,  53., 83., 113., 29.,  67., 105., 143., 35., 81.,
      127., 173., 41., 95., 149., 203., 47., 109., 171., 233.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x2x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,   110., 150., 70.,   174.,  278., 382., 110.,  278., 446.,
      614., 150.,  382., 614., 846.,  190.,  486., 782., 1078., 230., 590.,
      950., 1310., 270., 694., 1118., 1542., 310., 798., 1286., 1774.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x2x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,   110., 150., 70.,   174.,  278., 382., 110.,  278., 446.,
      614., 150.,  382., 614., 846.,  190.,  486., 782., 1078., 230., 590.,
      950., 1310., 270., 694., 1118., 1542., 310., 798., 1286., 1774.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 11., 17., 23., 29., 35.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 11., 17., 23., 29., 35.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 70., 110., 150., 190., 230.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 70., 110., 150., 190., 230.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 2., 4.,  3., 6.,
                                         4., 8., 5., 10., 6., 12.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 2., 4.,  3., 6.,
                                         4., 8., 5., 10., 6., 12.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 11., 25., 17., 39.,
                                         23., 53., 29., 67., 35., 81.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 11., 25., 17., 39.,
                                         23., 53., 29., 67., 35., 81.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  70.,  174., 110., 278.,
                                         150., 382., 190., 486., 230., 590.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  70.,  174., 110., 278.,
                                         150., 382., 190., 486., 230., 590.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11., 17., 23.,  11., 25., 39.,  53.,  17., 39., 61.,  83.,
      23., 53., 83., 113., 29., 67., 105., 143., 35., 81., 127., 173.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11., 17., 23.,  11., 25., 39.,  53.,  17., 39., 61.,  83.,
      23., 53., 83., 113., 29., 67., 105., 143., 35., 81., 127., 173.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,  110., 150., 70.,  174., 278., 382.,  110., 278., 446., 614.,
      150., 382., 614., 846., 190., 486., 782., 1078., 230., 590., 950., 1310.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,  110., 150., 70.,  174., 278., 382.,  110., 278., 446., 614.,
      150., 382., 614., 846., 190., 486., 782., 1078., 230., 590., 950., 1310.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8., 9.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8., 9.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29.,
                                         35., 41., 47., 53.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29.,
                                         35., 41., 47., 53.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190.,
                                         230., 270., 310., 350.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190.,
                                         230., 270., 310., 350.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2., 4.,  3., 6.,
                                         4., 8.,  5., 10., 6., 12.,
                                         7., 14., 8., 16., 9., 18.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2., 4.,  3., 6.,
                                         4., 8.,  5., 10., 6., 12.,
                                         7., 14., 8., 16., 9., 18.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 11., 25.,  17., 39.,
                                         23., 53., 29., 67.,  35., 81.,
                                         41., 95., 47., 109., 53., 123.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 11., 25.,  17., 39.,
                                         23., 53., 29., 67.,  35., 81.,
                                         41., 95., 47., 109., 53., 123.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  70.,  174., 110., 278.,
                                         150., 382., 190., 486., 230., 590.,
                                         270., 694., 310., 798., 350., 902.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  70.,  174., 110., 278.,
                                         150., 382., 190., 486., 230., 590.,
                                         270., 694., 310., 798., 350., 902.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1., 2.,  3.,  4.,  2., 4.,  6.,  8.,  3., 6.,  9.,  12.,
      4., 8.,  12., 16., 5., 10., 15., 20., 6., 12., 18., 24.,
      7., 14., 21., 28., 8., 16., 24., 32., 9., 18., 27., 36.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1., 2.,  3.,  4.,  2., 4.,  6.,  8.,  3., 6.,  9.,  12.,
      4., 8.,  12., 16., 5., 10., 15., 20., 6., 12., 18., 24.,
      7., 14., 21., 28., 8., 16., 24., 32., 9., 18., 27., 36.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11., 17.,  23.,  11., 25.,  39.,  53.,  17., 39.,  61.,  83.,
      23., 53., 83.,  113., 29., 67.,  105., 143., 35., 81.,  127., 173.,
      41., 95., 149., 203., 47., 109., 171., 233., 53., 123., 193., 263.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11., 17.,  23.,  11., 25.,  39.,  53.,  17., 39.,  61.,  83.,
      23., 53., 83.,  113., 29., 67.,  105., 143., 35., 81.,  127., 173.,
      41., 95., 149., 203., 47., 109., 171., 233., 53., 123., 193., 263.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110., 150.,  70.,   174.,  278., 382.,  110.,
      278.,  446.,  614., 150.,  382.,  614.,  846., 190.,  486.,
      782.,  1078., 230., 590.,  950.,  1310., 270., 694.,  1118.,
      1542., 310.,  798., 1286., 1774., 350.,  902., 1454., 2006.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110., 150.,  70.,   174.,  278., 382.,  110.,
      278.,  446.,  614., 150.,  382.,  614.,  846., 190.,  486.,
      782.,  1078., 230., 590.,  950.,  1310., 270., 694.,  1118.,
      1542., 310.,  798., 1286., 1774., 350.,  902., 1454., 2006.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29., 35.,
                                         41., 47., 53., 59., 65., 71.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29., 35.,
                                         41., 47., 53., 59., 65., 71.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2.,  4.,  3.,  6.,  4.,  8.,
                                         5., 10., 6.,  12., 7.,  14., 8.,  16.,
                                         9., 18., 10., 20., 11., 22., 12., 24.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2.,  4.,  3.,  6.,  4.,  8.,
                                         5., 10., 6.,  12., 7.,  14., 8.,  16.,
                                         9., 18., 10., 20., 11., 22., 12., 24.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11., 11., 25.,  17., 39.,  23., 53.,  29., 67.,  35., 81.,
      41., 95., 47., 109., 53., 123., 59., 137., 65., 151., 71., 165.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11., 11., 25.,  17., 39.,  23., 53.,  29., 67.,  35., 81.,
      41., 95., 47., 109., 53., 123., 59., 137., 65., 151., 71., 165.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,   70.,  174.,  110., 278.,
                                         150., 382.,  190., 486.,  230., 590.,
                                         270., 694.,  310., 798.,  350., 902.,
                                         390., 1006., 430., 1110., 470., 1214.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,   70.,  174.,  110., 278.,
                                         150., 382.,  190., 486.,  230., 590.,
                                         270., 694.,  310., 798.,  350., 902.,
                                         390., 1006., 430., 1110., 470., 1214.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12.,
      4.,  8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24.,
      7.,  14., 21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36.,
      10., 20., 30., 40., 11., 22., 33., 44., 12., 24., 36., 48.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12.,
      4.,  8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24.,
      7.,  14., 21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36.,
      10., 20., 30., 40., 11., 22., 33., 44., 12., 24., 36., 48.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11.,  17.,  23.,  11., 25.,  39.,  53.,  17., 39.,  61.,  83.,
      23., 53.,  83.,  113., 29., 67.,  105., 143., 35., 81.,  127., 173.,
      41., 95.,  149., 203., 47., 109., 171., 233., 53., 123., 193., 263.,
      59., 137., 215., 293., 65., 151., 237., 323., 71., 165., 259., 353.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11.,  17.,  23.,  11., 25.,  39.,  53.,  17., 39.,  61.,  83.,
      23., 53.,  83.,  113., 29., 67.,  105., 143., 35., 81.,  127., 173.,
      41., 95.,  149., 203., 47., 109., 171., 233., 53., 123., 193., 263.,
      59., 137., 215., 293., 65., 151., 237., 323., 71., 165., 259., 353.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  70.,   174.,  278.,  382.,  110.,  278.,
      446.,  614.,  150.,  382.,  614.,  846.,  190.,  486.,  782.,  1078.,
      230.,  590.,  950.,  1310., 270.,  694.,  1118., 1542., 310.,  798.,
      1286., 1774., 350.,  902.,  1454., 2006., 390.,  1006., 1622., 2238.,
      430.,  1110., 1790., 2470., 470.,  1214., 1958., 2702.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  70.,   174.,  278.,  382.,  110.,  278.,
      446.,  614.,  150.,  382.,  614.,  846.,  190.,  486.,  782.,  1078.,
      230.,  590.,  950.,  1310., 270.,  694.,  1118., 1542., 310.,  798.,
      1286., 1774., 350.,  902.,  1454., 2006., 390.,  1006., 1622., 2238.,
      430.,  1110., 1790., 2470., 470.,  1214., 1958., 2702.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 11., 17., 23., 29., 35., 41., 47.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 11., 17., 23., 29., 35., 41., 47.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150.,
                                         190., 230., 270., 310.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150.,
                                         190., 230., 270., 310.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2., 4.,  3., 6.,  4., 8.,
                                         5., 10., 6., 12., 7., 14., 8., 16.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2., 4.,  3., 6.,  4., 8.,
                                         5., 10., 6., 12., 7., 14., 8., 16.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 11., 25., 17., 39.,
                                         23., 53., 29., 67., 35., 81.,
                                         41., 95., 47., 109.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 11., 25., 17., 39.,
                                         23., 53., 29., 67., 35., 81.,
                                         41., 95., 47., 109.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  70.,  174., 110., 278.,
                                         150., 382., 190., 486., 230., 590.,
                                         270., 694., 310., 798.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  70.,  174., 110., 278.,
                                         150., 382., 190., 486., 230., 590.,
                                         270., 694., 310., 798.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.,
                                         7., 14., 21., 28., 8., 16., 24., 32.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.,
                                         7., 14., 21., 28., 8., 16., 24., 32.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17., 23., 11.,  25.,  39., 53.,  17.,  39., 61.,
      83.,  23.,  53., 83., 113., 29.,  67., 105., 143., 35., 81.,
      127., 173., 41., 95., 149., 203., 47., 109., 171., 233.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17., 23., 11.,  25.,  39., 53.,  17.,  39., 61.,
      83.,  23.,  53., 83., 113., 29.,  67., 105., 143., 35., 81.,
      127., 173., 41., 95., 149., 203., 47., 109., 171., 233.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,   110., 150., 70.,   174.,  278., 382., 110.,  278., 446.,
      614., 150.,  382., 614., 846.,  190.,  486., 782., 1078., 230., 590.,
      950., 1310., 270., 694., 1118., 1542., 310., 798., 1286., 1774.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,   110., 150., 70.,   174.,  278., 382., 110.,  278., 446.,
      614., 150.,  382., 614., 846.,  190.,  486., 782., 1078., 230., 590.,
      950., 1310., 270., 694., 1118., 1542., 310., 798., 1286., 1774.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29., 35.,
                                         41., 47., 53., 59., 65., 71.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29., 35.,
                                         41., 47., 53., 59., 65., 71.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2.,  4.,  3.,  6.,  4.,  8.,
                                         5., 10., 6.,  12., 7.,  14., 8.,  16.,
                                         9., 18., 10., 20., 11., 22., 12., 24.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2.,  4.,  3.,  6.,  4.,  8.,
                                         5., 10., 6.,  12., 7.,  14., 8.,  16.,
                                         9., 18., 10., 20., 11., 22., 12., 24.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11., 11., 25.,  17., 39.,  23., 53.,  29., 67.,  35., 81.,
      41., 95., 47., 109., 53., 123., 59., 137., 65., 151., 71., 165.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11., 11., 25.,  17., 39.,  23., 53.,  29., 67.,  35., 81.,
      41., 95., 47., 109., 53., 123., 59., 137., 65., 151., 71., 165.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,   70.,  174.,  110., 278.,
                                         150., 382.,  190., 486.,  230., 590.,
                                         270., 694.,  310., 798.,  350., 902.,
                                         390., 1006., 430., 1110., 470., 1214.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,   70.,  174.,  110., 278.,
                                         150., 382.,  190., 486.,  230., 590.,
                                         270., 694.,  310., 798.,  350., 902.,
                                         390., 1006., 430., 1110., 470., 1214.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12.,
      4.,  8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24.,
      7.,  14., 21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36.,
      10., 20., 30., 40., 11., 22., 33., 44., 12., 24., 36., 48.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12.,
      4.,  8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24.,
      7.,  14., 21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36.,
      10., 20., 30., 40., 11., 22., 33., 44., 12., 24., 36., 48.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11.,  17.,  23.,  11., 25.,  39.,  53.,  17., 39.,  61.,  83.,
      23., 53.,  83.,  113., 29., 67.,  105., 143., 35., 81.,  127., 173.,
      41., 95.,  149., 203., 47., 109., 171., 233., 53., 123., 193., 263.,
      59., 137., 215., 293., 65., 151., 237., 323., 71., 165., 259., 353.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11.,  17.,  23.,  11., 25.,  39.,  53.,  17., 39.,  61.,  83.,
      23., 53.,  83.,  113., 29., 67.,  105., 143., 35., 81.,  127., 173.,
      41., 95.,  149., 203., 47., 109., 171., 233., 53., 123., 193., 263.,
      59., 137., 215., 293., 65., 151., 237., 323., 71., 165., 259., 353.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  70.,   174.,  278.,  382.,  110.,  278.,
      446.,  614.,  150.,  382.,  614.,  846.,  190.,  486.,  782.,  1078.,
      230.,  590.,  950.,  1310., 270.,  694.,  1118., 1542., 310.,  798.,
      1286., 1774., 350.,  902.,  1454., 2006., 390.,  1006., 1622., 2238.,
      430.,  1110., 1790., 2470., 470.,  1214., 1958., 2702.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  70.,   174.,  278.,  382.,  110.,  278.,
      446.,  614.,  150.,  382.,  614.,  846.,  190.,  486.,  782.,  1078.,
      230.,  590.,  950.,  1310., 270.,  694.,  1118., 1542., 310.,  798.,
      1286., 1774., 350.,  902.,  1454., 2006., 390.,  1006., 1622., 2238.,
      430.,  1110., 1790., 2470., 470.,  1214., 1958., 2702.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  5.,  6.,  7.,  8.,
                                         9., 10., 11., 12., 13., 14., 15., 16.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  5.,  6.,  7.,  8.,
                                         9., 10., 11., 12., 13., 14., 15., 16.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29., 35.,
                                         41., 47., 53., 59., 65., 71.,
                                         77., 83., 89., 95.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29., 35.,
                                         41., 47., 53., 59., 65., 71.,
                                         77., 83., 89., 95.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.,
                                         510., 550., 590., 630.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.,
                                         510., 550., 590., 630.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,
      12., 7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22.,
      12., 24., 13., 26., 14., 28., 15., 30., 16., 32.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,
      12., 7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22.,
      12., 24., 13., 26., 14., 28., 15., 30., 16., 32.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11.,  11., 25.,  17.,  39.,  23.,  53.,  29.,  67., 35.,
      81., 41.,  95., 47.,  109., 53.,  123., 59.,  137., 65., 151.,
      71., 165., 77., 179., 83.,  193., 89.,  207., 95.,  221.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11.,  11., 25.,  17.,  39.,  23.,  53.,  29.,  67., 35.,
      81., 41.,  95., 47.,  109., 53.,  123., 59.,  137., 65., 151.,
      71., 165., 77., 179., 83.,  193., 89.,  207., 95.,  221.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,   70.,  174.,  110., 278.,  150., 382.,  190.,  486., 230.,
      590., 270.,  694., 310.,  798., 350.,  902., 390.,  1006., 430., 1110.,
      470., 1214., 510., 1318., 550., 1422., 590., 1526., 630.,  1630.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,   70.,  174.,  110., 278.,  150., 382.,  190.,  486., 230.,
      590., 270.,  694., 310.,  798., 350.,  902., 390.,  1006., 430., 1110.,
      470., 1214., 510., 1318., 550., 1422., 590., 1526., 630.,  1630.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,
      8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14.,
      21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36., 10., 20., 30.,
      40., 11., 22., 33., 44., 12., 24., 36., 48., 13., 26., 39., 52.,
      14., 28., 42., 56., 15., 30., 45., 60., 16., 32., 48., 64.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,
      8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14.,
      21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36., 10., 20., 30.,
      40., 11., 22., 33., 44., 12., 24., 36., 48., 13., 26., 39., 52.,
      14., 28., 42., 56., 15., 30., 45., 60., 16., 32., 48., 64.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  11.,  25.,  39.,  53.,  17.,  39.,  61.,
      83.,  23.,  53.,  83.,  113., 29.,  67.,  105., 143., 35.,  81.,
      127., 173., 41.,  95.,  149., 203., 47.,  109., 171., 233., 53.,
      123., 193., 263., 59.,  137., 215., 293., 65.,  151., 237., 323.,
      71.,  165., 259., 353., 77.,  179., 281., 383., 83.,  193., 303.,
      413., 89.,  207., 325., 443., 95.,  221., 347., 473.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  11.,  25.,  39.,  53.,  17.,  39.,  61.,
      83.,  23.,  53.,  83.,  113., 29.,  67.,  105., 143., 35.,  81.,
      127., 173., 41.,  95.,  149., 203., 47.,  109., 171., 233., 53.,
      123., 193., 263., 59.,  137., 215., 293., 65.,  151., 237., 323.,
      71.,  165., 259., 353., 77.,  179., 281., 383., 83.,  193., 303.,
      413., 89.,  207., 325., 443., 95.,  221., 347., 473.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME1x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  70.,   174.,  278.,  382.,  110.,  278.,
      446.,  614.,  150.,  382.,  614.,  846.,  190.,  486.,  782.,  1078.,
      230.,  590.,  950.,  1310., 270.,  694.,  1118., 1542., 310.,  798.,
      1286., 1774., 350.,  902.,  1454., 2006., 390.,  1006., 1622., 2238.,
      430.,  1110., 1790., 2470., 470.,  1214., 1958., 2702., 510.,  1318.,
      2126., 2934., 550.,  1422., 2294., 3166., 590.,  1526., 2462., 3398.,
      630.,  1630., 2630., 3630.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID1x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  70.,   174.,  278.,  382.,  110.,  278.,
      446.,  614.,  150.,  382.,  614.,  846.,  190.,  486.,  782.,  1078.,
      230.,  590.,  950.,  1310., 270.,  694.,  1118., 1542., 310.,  798.,
      1286., 1774., 350.,  902.,  1454., 2006., 390.,  1006., 1622., 2238.,
      430.,  1110., 1790., 2470., 470.,  1214., 1958., 2702., 510.,  1318.,
      2126., 2934., 550.,  1422., 2294., 3166., 590.,  1526., 2462., 3398.,
      630.,  1630., 2630., 3630.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29., 35.,
                                         41., 47., 53., 59., 65., 71.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29., 35.,
                                         41., 47., 53., 59., 65., 71.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2.,  4.,  3.,  6.,  4.,  8.,
                                         5., 10., 6.,  12., 7.,  14., 8.,  16.,
                                         9., 18., 10., 20., 11., 22., 12., 24.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2.,  4.,  3.,  6.,  4.,  8.,
                                         5., 10., 6.,  12., 7.,  14., 8.,  16.,
                                         9., 18., 10., 20., 11., 22., 12., 24.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11., 11., 25.,  17., 39.,  23., 53.,  29., 67.,  35., 81.,
      41., 95., 47., 109., 53., 123., 59., 137., 65., 151., 71., 165.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11., 11., 25.,  17., 39.,  23., 53.,  29., 67.,  35., 81.,
      41., 95., 47., 109., 53., 123., 59., 137., 65., 151., 71., 165.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,   70.,  174.,  110., 278.,
                                         150., 382.,  190., 486.,  230., 590.,
                                         270., 694.,  310., 798.,  350., 902.,
                                         390., 1006., 430., 1110., 470., 1214.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,   70.,  174.,  110., 278.,
                                         150., 382.,  190., 486.,  230., 590.,
                                         270., 694.,  310., 798.,  350., 902.,
                                         390., 1006., 430., 1110., 470., 1214.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12.,
      4.,  8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24.,
      7.,  14., 21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36.,
      10., 20., 30., 40., 11., 22., 33., 44., 12., 24., 36., 48.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12.,
      4.,  8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24.,
      7.,  14., 21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36.,
      10., 20., 30., 40., 11., 22., 33., 44., 12., 24., 36., 48.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11.,  17.,  23.,  11., 25.,  39.,  53.,  17., 39.,  61.,  83.,
      23., 53.,  83.,  113., 29., 67.,  105., 143., 35., 81.,  127., 173.,
      41., 95.,  149., 203., 47., 109., 171., 233., 53., 123., 193., 263.,
      59., 137., 215., 293., 65., 151., 237., 323., 71., 165., 259., 353.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11.,  17.,  23.,  11., 25.,  39.,  53.,  17., 39.,  61.,  83.,
      23., 53.,  83.,  113., 29., 67.,  105., 143., 35., 81.,  127., 173.,
      41., 95.,  149., 203., 47., 109., 171., 233., 53., 123., 193., 263.,
      59., 137., 215., 293., 65., 151., 237., 323., 71., 165., 259., 353.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  70.,   174.,  278.,  382.,  110.,  278.,
      446.,  614.,  150.,  382.,  614.,  846.,  190.,  486.,  782.,  1078.,
      230.,  590.,  950.,  1310., 270.,  694.,  1118., 1542., 310.,  798.,
      1286., 1774., 350.,  902.,  1454., 2006., 390.,  1006., 1622., 2238.,
      430.,  1110., 1790., 2470., 470.,  1214., 1958., 2702.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  70.,   174.,  278.,  382.,  110.,  278.,
      446.,  614.,  150.,  382.,  614.,  846.,  190.,  486.,  782.,  1078.,
      230.,  590.,  950.,  1310., 270.,  694.,  1118., 1542., 310.,  798.,
      1286., 1774., 350.,  902.,  1454., 2006., 390.,  1006., 1622., 2238.,
      430.,  1110., 1790., 2470., 470.,  1214., 1958., 2702.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  4.,  5.,  6.,
                                         7.,  8.,  9.,  10., 11., 12.,
                                         13., 14., 15., 16., 17., 18.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  4.,  5.,  6.,
                                         7.,  8.,  9.,  10., 11., 12.,
                                         13., 14., 15., 16., 17., 18.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29.,  35.,
                                         41., 47., 53., 59., 65.,  71.,
                                         77., 83., 89., 95., 101., 107.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29.,  35.,
                                         41., 47., 53., 59., 65.,  71.,
                                         77., 83., 89., 95., 101., 107.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.,
                                         510., 550., 590., 630., 670., 710.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.,
                                         510., 550., 590., 630., 670., 710.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11.,  11., 25.,  17., 39.,  23., 53.,  29.,  67.,  35.,  81.,
      41., 95.,  47., 109., 53., 123., 59., 137., 65.,  151., 71.,  165.,
      77., 179., 83., 193., 89., 207., 95., 221., 101., 235., 107., 249.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11.,  11., 25.,  17., 39.,  23., 53.,  29.,  67.,  35.,  81.,
      41., 95.,  47., 109., 53., 123., 59., 137., 65.,  151., 71.,  165.,
      77., 179., 83., 193., 89., 207., 95., 221., 101., 235., 107., 249.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   70.,   174.,  110.,  278.,  150.,  382.,  190.,
      486.,  230.,  590.,  270.,  694.,  310.,  798.,  350.,  902.,
      390.,  1006., 430.,  1110., 470.,  1214., 510.,  1318., 550.,
      1422., 590.,  1526., 630.,  1630., 670.,  1734., 710.,  1838.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   70.,   174.,  110.,  278.,  150.,  382.,  190.,
      486.,  230.,  590.,  270.,  694.,  310.,  798.,  350.,  902.,
      390.,  1006., 430.,  1110., 470.,  1214., 510.,  1318., 550.,
      1422., 590.,  1526., 630.,  1630., 670.,  1734., 710.,  1838.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,  12.,
      16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28., 8.,  16.,
      24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22., 33., 44., 12.,
      24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56., 15., 30., 45., 60.,
      16., 32., 48., 64., 17., 34., 51., 68., 18., 36., 54., 72.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,  12.,
      16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28., 8.,  16.,
      24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22., 33., 44., 12.,
      24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56., 15., 30., 45., 60.,
      16., 32., 48., 64., 17., 34., 51., 68., 18., 36., 54., 72.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11.,  17.,  23.,  11.,  25.,  39.,  53.,  17.,  39.,  61.,  83.,
      23., 53.,  83.,  113., 29.,  67.,  105., 143., 35.,  81.,  127., 173.,
      41., 95.,  149., 203., 47.,  109., 171., 233., 53.,  123., 193., 263.,
      59., 137., 215., 293., 65.,  151., 237., 323., 71.,  165., 259., 353.,
      77., 179., 281., 383., 83.,  193., 303., 413., 89.,  207., 325., 443.,
      95., 221., 347., 473., 101., 235., 369., 503., 107., 249., 391., 533.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11.,  17.,  23.,  11.,  25.,  39.,  53.,  17.,  39.,  61.,  83.,
      23., 53.,  83.,  113., 29.,  67.,  105., 143., 35.,  81.,  127., 173.,
      41., 95.,  149., 203., 47.,  109., 171., 233., 53.,  123., 193., 263.,
      59., 137., 215., 293., 65.,  151., 237., 323., 71.,  165., 259., 353.,
      77., 179., 281., 383., 83.,  193., 303., 413., 89.,  207., 325., 443.,
      95., 221., 347., 473., 101., 235., 369., 503., 107., 249., 391., 533.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  70.,   174.,  278.,  382.,  110.,
      278.,  446.,  614.,  150.,  382.,  614.,  846.,  190.,  486.,
      782.,  1078., 230.,  590.,  950.,  1310., 270.,  694.,  1118.,
      1542., 310.,  798.,  1286., 1774., 350.,  902.,  1454., 2006.,
      390.,  1006., 1622., 2238., 430.,  1110., 1790., 2470., 470.,
      1214., 1958., 2702., 510.,  1318., 2126., 2934., 550.,  1422.,
      2294., 3166., 590.,  1526., 2462., 3398., 630.,  1630., 2630.,
      3630., 670.,  1734., 2798., 3862., 710.,  1838., 2966., 4094.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  70.,   174.,  278.,  382.,  110.,
      278.,  446.,  614.,  150.,  382.,  614.,  846.,  190.,  486.,
      782.,  1078., 230.,  590.,  950.,  1310., 270.,  694.,  1118.,
      1542., 310.,  798.,  1286., 1774., 350.,  902.,  1454., 2006.,
      390.,  1006., 1622., 2238., 430.,  1110., 1790., 2470., 470.,
      1214., 1958., 2702., 510.,  1318., 2126., 2934., 550.,  1422.,
      2294., 3166., 590.,  1526., 2462., 3398., 630.,  1630., 2630.,
      3630., 670.,  1734., 2798., 3862., 710.,  1838., 2966., 4094.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11., 17., 23., 29.,  35.,  41.,  47.,  53.,  59.,  65.,  71.,
      77., 83., 89., 95., 101., 107., 113., 119., 125., 131., 137., 143.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11., 17., 23., 29.,  35.,  41.,  47.,  53.,  59.,  65.,  71.,
      77., 83., 89., 95., 101., 107., 113., 119., 125., 131., 137., 143.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,  110., 150., 190., 230., 270., 310., 350., 390., 430., 470.,
      510., 550., 590., 630., 670., 710., 750., 790., 830., 870., 910., 950.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,  110., 150., 190., 230., 270., 310., 350., 390., 430., 470.,
      510., 550., 590., 630., 670., 710., 750., 790., 830., 870., 910., 950.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.,
      19., 38., 20., 40., 21., 42., 22., 44., 23., 46., 24., 48.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.,
      19., 38., 20., 40., 21., 42., 22., 44., 23., 46., 24., 48.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  11.,  25.,  17.,  39.,  23.,  53.,  29.,  67.,  35.,  81.,
      41.,  95.,  47.,  109., 53.,  123., 59.,  137., 65.,  151., 71.,  165.,
      77.,  179., 83.,  193., 89.,  207., 95.,  221., 101., 235., 107., 249.,
      113., 263., 119., 277., 125., 291., 131., 305., 137., 319., 143., 333.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  11.,  25.,  17.,  39.,  23.,  53.,  29.,  67.,  35.,  81.,
      41.,  95.,  47.,  109., 53.,  123., 59.,  137., 65.,  151., 71.,  165.,
      77.,  179., 83.,  193., 89.,  207., 95.,  221., 101., 235., 107., 249.,
      113., 263., 119., 277., 125., 291., 131., 305., 137., 319., 143., 333.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,   70.,  174.,  110., 278.,  150., 382.,  190., 486.,
      230., 590.,  270., 694.,  310., 798.,  350., 902.,  390., 1006.,
      430., 1110., 470., 1214., 510., 1318., 550., 1422., 590., 1526.,
      630., 1630., 670., 1734., 710., 1838., 750., 1942., 790., 2046.,
      830., 2150., 870., 2254., 910., 2358., 950., 2462.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,   70.,  174.,  110., 278.,  150., 382.,  190., 486.,
      230., 590.,  270., 694.,  310., 798.,  350., 902.,  390., 1006.,
      430., 1110., 470., 1214., 510., 1318., 550., 1422., 590., 1526.,
      630., 1630., 670., 1734., 710., 1838., 750., 1942., 790., 2046.,
      830., 2150., 870., 2254., 910., 2358., 950., 2462.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,
      12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28.,
      8.,  16., 24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22.,
      33., 44., 12., 24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56.,
      15., 30., 45., 60., 16., 32., 48., 64., 17., 34., 51., 68., 18., 36.,
      54., 72., 19., 38., 57., 76., 20., 40., 60., 80., 21., 42., 63., 84.,
      22., 44., 66., 88., 23., 46., 69., 92., 24., 48., 72., 96.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,
      12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28.,
      8.,  16., 24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22.,
      33., 44., 12., 24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56.,
      15., 30., 45., 60., 16., 32., 48., 64., 17., 34., 51., 68., 18., 36.,
      54., 72., 19., 38., 57., 76., 20., 40., 60., 80., 21., 42., 63., 84.,
      22., 44., 66., 88., 23., 46., 69., 92., 24., 48., 72., 96.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  11.,  25.,  39.,  53.,  17.,  39.,  61.,  83.,
      23.,  53.,  83.,  113., 29.,  67.,  105., 143., 35.,  81.,  127., 173.,
      41.,  95.,  149., 203., 47.,  109., 171., 233., 53.,  123., 193., 263.,
      59.,  137., 215., 293., 65.,  151., 237., 323., 71.,  165., 259., 353.,
      77.,  179., 281., 383., 83.,  193., 303., 413., 89.,  207., 325., 443.,
      95.,  221., 347., 473., 101., 235., 369., 503., 107., 249., 391., 533.,
      113., 263., 413., 563., 119., 277., 435., 593., 125., 291., 457., 623.,
      131., 305., 479., 653., 137., 319., 501., 683., 143., 333., 523., 713.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  11.,  25.,  39.,  53.,  17.,  39.,  61.,  83.,
      23.,  53.,  83.,  113., 29.,  67.,  105., 143., 35.,  81.,  127., 173.,
      41.,  95.,  149., 203., 47.,  109., 171., 233., 53.,  123., 193., 263.,
      59.,  137., 215., 293., 65.,  151., 237., 323., 71.,  165., 259., 353.,
      77.,  179., 281., 383., 83.,  193., 303., 413., 89.,  207., 325., 443.,
      95.,  221., 347., 473., 101., 235., 369., 503., 107., 249., 391., 533.,
      113., 263., 413., 563., 119., 277., 435., 593., 125., 291., 457., 623.,
      131., 305., 479., 653., 137., 319., 501., 683., 143., 333., 523., 713.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x2x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  70.,   174.,  278.,  382.,  110.,  278.,
      446.,  614.,  150.,  382.,  614.,  846.,  190.,  486.,  782.,  1078.,
      230.,  590.,  950.,  1310., 270.,  694.,  1118., 1542., 310.,  798.,
      1286., 1774., 350.,  902.,  1454., 2006., 390.,  1006., 1622., 2238.,
      430.,  1110., 1790., 2470., 470.,  1214., 1958., 2702., 510.,  1318.,
      2126., 2934., 550.,  1422., 2294., 3166., 590.,  1526., 2462., 3398.,
      630.,  1630., 2630., 3630., 670.,  1734., 2798., 3862., 710.,  1838.,
      2966., 4094., 750.,  1942., 3134., 4326., 790.,  2046., 3302., 4558.,
      830.,  2150., 3470., 4790., 870.,  2254., 3638., 5022., 910.,  2358.,
      3806., 5254., 950.,  2462., 3974., 5486.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x2x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  70.,   174.,  278.,  382.,  110.,  278.,
      446.,  614.,  150.,  382.,  614.,  846.,  190.,  486.,  782.,  1078.,
      230.,  590.,  950.,  1310., 270.,  694.,  1118., 1542., 310.,  798.,
      1286., 1774., 350.,  902.,  1454., 2006., 390.,  1006., 1622., 2238.,
      430.,  1110., 1790., 2470., 470.,  1214., 1958., 2702., 510.,  1318.,
      2126., 2934., 550.,  1422., 2294., 3166., 590.,  1526., 2462., 3398.,
      630.,  1630., 2630., 3630., 670.,  1734., 2798., 3862., 710.,  1838.,
      2966., 4094., 750.,  1942., 3134., 4326., 790.,  2046., 3302., 4558.,
      830.,  2150., 3470., 4790., 870.,  2254., 3638., 5022., 910.,  2358.,
      3806., 5254., 950.,  2462., 3974., 5486.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  4.,  5.,  6.,
                                         7.,  8.,  9.,  10., 11., 12.,
                                         13., 14., 15., 16., 17., 18.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  4.,  5.,  6.,
                                         7.,  8.,  9.,  10., 11., 12.,
                                         13., 14., 15., 16., 17., 18.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29.,  35.,
                                         41., 47., 53., 59., 65.,  71.,
                                         77., 83., 89., 95., 101., 107.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29.,  35.,
                                         41., 47., 53., 59., 65.,  71.,
                                         77., 83., 89., 95., 101., 107.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.,
                                         510., 550., 590., 630., 670., 710.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.,
                                         510., 550., 590., 630., 670., 710.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11.,  11., 25.,  17., 39.,  23., 53.,  29.,  67.,  35.,  81.,
      41., 95.,  47., 109., 53., 123., 59., 137., 65.,  151., 71.,  165.,
      77., 179., 83., 193., 89., 207., 95., 221., 101., 235., 107., 249.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11.,  11., 25.,  17., 39.,  23., 53.,  29.,  67.,  35.,  81.,
      41., 95.,  47., 109., 53., 123., 59., 137., 65.,  151., 71.,  165.,
      77., 179., 83., 193., 89., 207., 95., 221., 101., 235., 107., 249.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   70.,   174.,  110.,  278.,  150.,  382.,  190.,
      486.,  230.,  590.,  270.,  694.,  310.,  798.,  350.,  902.,
      390.,  1006., 430.,  1110., 470.,  1214., 510.,  1318., 550.,
      1422., 590.,  1526., 630.,  1630., 670.,  1734., 710.,  1838.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   70.,   174.,  110.,  278.,  150.,  382.,  190.,
      486.,  230.,  590.,  270.,  694.,  310.,  798.,  350.,  902.,
      390.,  1006., 430.,  1110., 470.,  1214., 510.,  1318., 550.,
      1422., 590.,  1526., 630.,  1630., 670.,  1734., 710.,  1838.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,  12.,
      16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28., 8.,  16.,
      24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22., 33., 44., 12.,
      24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56., 15., 30., 45., 60.,
      16., 32., 48., 64., 17., 34., 51., 68., 18., 36., 54., 72.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,  12.,
      16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28., 8.,  16.,
      24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22., 33., 44., 12.,
      24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56., 15., 30., 45., 60.,
      16., 32., 48., 64., 17., 34., 51., 68., 18., 36., 54., 72.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11.,  17.,  23.,  11.,  25.,  39.,  53.,  17.,  39.,  61.,  83.,
      23., 53.,  83.,  113., 29.,  67.,  105., 143., 35.,  81.,  127., 173.,
      41., 95.,  149., 203., 47.,  109., 171., 233., 53.,  123., 193., 263.,
      59., 137., 215., 293., 65.,  151., 237., 323., 71.,  165., 259., 353.,
      77., 179., 281., 383., 83.,  193., 303., 413., 89.,  207., 325., 443.,
      95., 221., 347., 473., 101., 235., 369., 503., 107., 249., 391., 533.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11.,  17.,  23.,  11.,  25.,  39.,  53.,  17.,  39.,  61.,  83.,
      23., 53.,  83.,  113., 29.,  67.,  105., 143., 35.,  81.,  127., 173.,
      41., 95.,  149., 203., 47.,  109., 171., 233., 53.,  123., 193., 263.,
      59., 137., 215., 293., 65.,  151., 237., 323., 71.,  165., 259., 353.,
      77., 179., 281., 383., 83.,  193., 303., 413., 89.,  207., 325., 443.,
      95., 221., 347., 473., 101., 235., 369., 503., 107., 249., 391., 533.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  70.,   174.,  278.,  382.,  110.,
      278.,  446.,  614.,  150.,  382.,  614.,  846.,  190.,  486.,
      782.,  1078., 230.,  590.,  950.,  1310., 270.,  694.,  1118.,
      1542., 310.,  798.,  1286., 1774., 350.,  902.,  1454., 2006.,
      390.,  1006., 1622., 2238., 430.,  1110., 1790., 2470., 470.,
      1214., 1958., 2702., 510.,  1318., 2126., 2934., 550.,  1422.,
      2294., 3166., 590.,  1526., 2462., 3398., 630.,  1630., 2630.,
      3630., 670.,  1734., 2798., 3862., 710.,  1838., 2966., 4094.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  70.,   174.,  278.,  382.,  110.,
      278.,  446.,  614.,  150.,  382.,  614.,  846.,  190.,  486.,
      782.,  1078., 230.,  590.,  950.,  1310., 270.,  694.,  1118.,
      1542., 310.,  798.,  1286., 1774., 350.,  902.,  1454., 2006.,
      390.,  1006., 1622., 2238., 430.,  1110., 1790., 2470., 470.,
      1214., 1958., 2702., 510.,  1318., 2126., 2934., 550.,  1422.,
      2294., 3166., 590.,  1526., 2462., 3398., 630.,  1630., 2630.,
      3630., 670.,  1734., 2798., 3862., 710.,  1838., 2966., 4094.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14.,
      15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14.,
      15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  29.,  35.,  41.,  47.,  53.,
      59.,  65.,  71.,  77.,  83.,  89.,  95.,  101., 107.,
      113., 119., 125., 131., 137., 143., 149., 155., 161.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  29.,  35.,  41.,  47.,  53.,
      59.,  65.,  71.,  77.,  83.,  89.,  95.,  101., 107.,
      113., 119., 125., 131., 137., 143., 149., 155., 161.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,  110., 150., 190., 230., 270., 310.,  350.,
      390., 430., 470., 510., 550., 590., 630., 670.,  710.,
      750., 790., 830., 870., 910., 950., 990., 1030., 1070.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,  110., 150., 190., 230., 270., 310.,  350.,
      390., 430., 470., 510., 550., 590., 630., 670.,  710.,
      750., 790., 830., 870., 910., 950., 990., 1030., 1070.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14.,
      8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28.,
      15., 30., 16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42.,
      22., 44., 23., 46., 24., 48., 25., 50., 26., 52., 27., 54.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14.,
      8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28.,
      15., 30., 16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42.,
      22., 44., 23., 46., 24., 48., 25., 50., 26., 52., 27., 54.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  11.,  25.,  17.,  39.,  23.,  53.,  29.,  67.,  35.,
      81.,  41.,  95.,  47.,  109., 53.,  123., 59.,  137., 65.,  151.,
      71.,  165., 77.,  179., 83.,  193., 89.,  207., 95.,  221., 101.,
      235., 107., 249., 113., 263., 119., 277., 125., 291., 131., 305.,
      137., 319., 143., 333., 149., 347., 155., 361., 161., 375.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  11.,  25.,  17.,  39.,  23.,  53.,  29.,  67.,  35.,
      81.,  41.,  95.,  47.,  109., 53.,  123., 59.,  137., 65.,  151.,
      71.,  165., 77.,  179., 83.,  193., 89.,  207., 95.,  221., 101.,
      235., 107., 249., 113., 263., 119., 277., 125., 291., 131., 305.,
      137., 319., 143., 333., 149., 347., 155., 361., 161., 375.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   70.,   174.,  110.,  278.,  150.,  382.,  190.,
      486.,  230.,  590.,  270.,  694.,  310.,  798.,  350.,  902.,
      390.,  1006., 430.,  1110., 470.,  1214., 510.,  1318., 550.,
      1422., 590.,  1526., 630.,  1630., 670.,  1734., 710.,  1838.,
      750.,  1942., 790.,  2046., 830.,  2150., 870.,  2254., 910.,
      2358., 950.,  2462., 990.,  2566., 1030., 2670., 1070., 2774.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   70.,   174.,  110.,  278.,  150.,  382.,  190.,
      486.,  230.,  590.,  270.,  694.,  310.,  798.,  350.,  902.,
      390.,  1006., 430.,  1110., 470.,  1214., 510.,  1318., 550.,
      1422., 590.,  1526., 630.,  1630., 670.,  1734., 710.,  1838.,
      750.,  1942., 790.,  2046., 830.,  2150., 870.,  2254., 910.,
      2358., 950.,  2462., 990.,  2566., 1030., 2670., 1070., 2774.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,   3.,  4.,  2.,  4.,   6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,
      12., 16.,  5.,  10., 15., 20.,  6.,  12., 18., 24., 7.,  14., 21., 28.,
      8.,  16.,  24., 32., 9.,  18.,  27., 36., 10., 20., 30., 40., 11., 22.,
      33., 44.,  12., 24., 36., 48.,  13., 26., 39., 52., 14., 28., 42., 56.,
      15., 30.,  45., 60., 16., 32.,  48., 64., 17., 34., 51., 68., 18., 36.,
      54., 72.,  19., 38., 57., 76.,  20., 40., 60., 80., 21., 42., 63., 84.,
      22., 44.,  66., 88., 23., 46.,  69., 92., 24., 48., 72., 96., 25., 50.,
      75., 100., 26., 52., 78., 104., 27., 54., 81., 108.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,   3.,  4.,  2.,  4.,   6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,
      12., 16.,  5.,  10., 15., 20.,  6.,  12., 18., 24., 7.,  14., 21., 28.,
      8.,  16.,  24., 32., 9.,  18.,  27., 36., 10., 20., 30., 40., 11., 22.,
      33., 44.,  12., 24., 36., 48.,  13., 26., 39., 52., 14., 28., 42., 56.,
      15., 30.,  45., 60., 16., 32.,  48., 64., 17., 34., 51., 68., 18., 36.,
      54., 72.,  19., 38., 57., 76.,  20., 40., 60., 80., 21., 42., 63., 84.,
      22., 44.,  66., 88., 23., 46.,  69., 92., 24., 48., 72., 96., 25., 50.,
      75., 100., 26., 52., 78., 104., 27., 54., 81., 108.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  11.,  25.,  39.,  53.,  17.,  39.,  61.,  83.,
      23.,  53.,  83.,  113., 29.,  67.,  105., 143., 35.,  81.,  127., 173.,
      41.,  95.,  149., 203., 47.,  109., 171., 233., 53.,  123., 193., 263.,
      59.,  137., 215., 293., 65.,  151., 237., 323., 71.,  165., 259., 353.,
      77.,  179., 281., 383., 83.,  193., 303., 413., 89.,  207., 325., 443.,
      95.,  221., 347., 473., 101., 235., 369., 503., 107., 249., 391., 533.,
      113., 263., 413., 563., 119., 277., 435., 593., 125., 291., 457., 623.,
      131., 305., 479., 653., 137., 319., 501., 683., 143., 333., 523., 713.,
      149., 347., 545., 743., 155., 361., 567., 773., 161., 375., 589., 803.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  11.,  25.,  39.,  53.,  17.,  39.,  61.,  83.,
      23.,  53.,  83.,  113., 29.,  67.,  105., 143., 35.,  81.,  127., 173.,
      41.,  95.,  149., 203., 47.,  109., 171., 233., 53.,  123., 193., 263.,
      59.,  137., 215., 293., 65.,  151., 237., 323., 71.,  165., 259., 353.,
      77.,  179., 281., 383., 83.,  193., 303., 413., 89.,  207., 325., 443.,
      95.,  221., 347., 473., 101., 235., 369., 503., 107., 249., 391., 533.,
      113., 263., 413., 563., 119., 277., 435., 593., 125., 291., 457., 623.,
      131., 305., 479., 653., 137., 319., 501., 683., 143., 333., 523., 713.,
      149., 347., 545., 743., 155., 361., 567., 773., 161., 375., 589., 803.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  70.,   174.,  278.,  382.,  110.,  278.,
      446.,  614.,  150.,  382.,  614.,  846.,  190.,  486.,  782.,  1078.,
      230.,  590.,  950.,  1310., 270.,  694.,  1118., 1542., 310.,  798.,
      1286., 1774., 350.,  902.,  1454., 2006., 390.,  1006., 1622., 2238.,
      430.,  1110., 1790., 2470., 470.,  1214., 1958., 2702., 510.,  1318.,
      2126., 2934., 550.,  1422., 2294., 3166., 590.,  1526., 2462., 3398.,
      630.,  1630., 2630., 3630., 670.,  1734., 2798., 3862., 710.,  1838.,
      2966., 4094., 750.,  1942., 3134., 4326., 790.,  2046., 3302., 4558.,
      830.,  2150., 3470., 4790., 870.,  2254., 3638., 5022., 910.,  2358.,
      3806., 5254., 950.,  2462., 3974., 5486., 990.,  2566., 4142., 5718.,
      1030., 2670., 4310., 5950., 1070., 2774., 4478., 6182.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  70.,   174.,  278.,  382.,  110.,  278.,
      446.,  614.,  150.,  382.,  614.,  846.,  190.,  486.,  782.,  1078.,
      230.,  590.,  950.,  1310., 270.,  694.,  1118., 1542., 310.,  798.,
      1286., 1774., 350.,  902.,  1454., 2006., 390.,  1006., 1622., 2238.,
      430.,  1110., 1790., 2470., 470.,  1214., 1958., 2702., 510.,  1318.,
      2126., 2934., 550.,  1422., 2294., 3166., 590.,  1526., 2462., 3398.,
      630.,  1630., 2630., 3630., 670.,  1734., 2798., 3862., 710.,  1838.,
      2966., 4094., 750.,  1942., 3134., 4326., 790.,  2046., 3302., 4558.,
      830.,  2150., 3470., 4790., 870.,  2254., 3638., 5022., 910.,  2358.,
      3806., 5254., 950.,  2462., 3974., 5486., 990.,  2566., 4142., 5718.,
      1030., 2670., 4310., 5950., 1070., 2774., 4478., 6182.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  29.,  35.,  41.,  47.,  53.,  59.,  65.,  71.,
      77.,  83.,  89.,  95.,  101., 107., 113., 119., 125., 131., 137., 143.,
      149., 155., 161., 167., 173., 179., 185., 191., 197., 203., 209., 215.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  29.,  35.,  41.,  47.,  53.,  59.,  65.,  71.,
      77.,  83.,  89.,  95.,  101., 107., 113., 119., 125., 131., 137., 143.,
      149., 155., 161., 167., 173., 179., 185., 191., 197., 203., 209., 215.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  190.,  230.,  270.,  310.,  350.,
      390.,  430.,  470.,  510.,  550.,  590.,  630.,  670.,  710.,
      750.,  790.,  830.,  870.,  910.,  950.,  990.,  1030., 1070.,
      1110., 1150., 1190., 1230., 1270., 1310., 1350., 1390., 1430.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  190.,  230.,  270.,  310.,  350.,
      390.,  430.,  470.,  510.,  550.,  590.,  630.,  670.,  710.,
      750.,  790.,  830.,  870.,  910.,  950.,  990.,  1030., 1070.,
      1110., 1150., 1190., 1230., 1270., 1310., 1350., 1390., 1430.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14., 8.,
      16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28., 15., 30.,
      16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42., 22., 44., 23.,
      46., 24., 48., 25., 50., 26., 52., 27., 54., 28., 56., 29., 58., 30., 60.,
      31., 62., 32., 64., 33., 66., 34., 68., 35., 70., 36., 72.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14., 8.,
      16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28., 15., 30.,
      16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42., 22., 44., 23.,
      46., 24., 48., 25., 50., 26., 52., 27., 54., 28., 56., 29., 58., 30., 60.,
      31., 62., 32., 64., 33., 66., 34., 68., 35., 70., 36., 72.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  11.,  25.,  17.,  39.,  23.,  53.,  29.,  67.,  35.,  81.,
      41.,  95.,  47.,  109., 53.,  123., 59.,  137., 65.,  151., 71.,  165.,
      77.,  179., 83.,  193., 89.,  207., 95.,  221., 101., 235., 107., 249.,
      113., 263., 119., 277., 125., 291., 131., 305., 137., 319., 143., 333.,
      149., 347., 155., 361., 161., 375., 167., 389., 173., 403., 179., 417.,
      185., 431., 191., 445., 197., 459., 203., 473., 209., 487., 215., 501.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  11.,  25.,  17.,  39.,  23.,  53.,  29.,  67.,  35.,  81.,
      41.,  95.,  47.,  109., 53.,  123., 59.,  137., 65.,  151., 71.,  165.,
      77.,  179., 83.,  193., 89.,  207., 95.,  221., 101., 235., 107., 249.,
      113., 263., 119., 277., 125., 291., 131., 305., 137., 319., 143., 333.,
      149., 347., 155., 361., 161., 375., 167., 389., 173., 403., 179., 417.,
      185., 431., 191., 445., 197., 459., 203., 473., 209., 487., 215., 501.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   70.,   174.,  110.,  278.,  150.,  382.,  190.,
      486.,  230.,  590.,  270.,  694.,  310.,  798.,  350.,  902.,
      390.,  1006., 430.,  1110., 470.,  1214., 510.,  1318., 550.,
      1422., 590.,  1526., 630.,  1630., 670.,  1734., 710.,  1838.,
      750.,  1942., 790.,  2046., 830.,  2150., 870.,  2254., 910.,
      2358., 950.,  2462., 990.,  2566., 1030., 2670., 1070., 2774.,
      1110., 2878., 1150., 2982., 1190., 3086., 1230., 3190., 1270.,
      3294., 1310., 3398., 1350., 3502., 1390., 3606., 1430., 3710.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   70.,   174.,  110.,  278.,  150.,  382.,  190.,
      486.,  230.,  590.,  270.,  694.,  310.,  798.,  350.,  902.,
      390.,  1006., 430.,  1110., 470.,  1214., 510.,  1318., 550.,
      1422., 590.,  1526., 630.,  1630., 670.,  1734., 710.,  1838.,
      750.,  1942., 790.,  2046., 830.,  2150., 870.,  2254., 910.,
      2358., 950.,  2462., 990.,  2566., 1030., 2670., 1070., 2774.,
      1110., 2878., 1150., 2982., 1190., 3086., 1230., 3190., 1270.,
      3294., 1310., 3398., 1350., 3502., 1390., 3606., 1430., 3710.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   2.,  4.,  6.,   8.,   3.,  6.,  9.,   12.,
      4.,  8.,  12.,  16.,  5.,  10., 15.,  20.,  6.,  12., 18.,  24.,
      7.,  14., 21.,  28.,  8.,  16., 24.,  32.,  9.,  18., 27.,  36.,
      10., 20., 30.,  40.,  11., 22., 33.,  44.,  12., 24., 36.,  48.,
      13., 26., 39.,  52.,  14., 28., 42.,  56.,  15., 30., 45.,  60.,
      16., 32., 48.,  64.,  17., 34., 51.,  68.,  18., 36., 54.,  72.,
      19., 38., 57.,  76.,  20., 40., 60.,  80.,  21., 42., 63.,  84.,
      22., 44., 66.,  88.,  23., 46., 69.,  92.,  24., 48., 72.,  96.,
      25., 50., 75.,  100., 26., 52., 78.,  104., 27., 54., 81.,  108.,
      28., 56., 84.,  112., 29., 58., 87.,  116., 30., 60., 90.,  120.,
      31., 62., 93.,  124., 32., 64., 96.,  128., 33., 66., 99.,  132.,
      34., 68., 102., 136., 35., 70., 105., 140., 36., 72., 108., 144.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   2.,  4.,  6.,   8.,   3.,  6.,  9.,   12.,
      4.,  8.,  12.,  16.,  5.,  10., 15.,  20.,  6.,  12., 18.,  24.,
      7.,  14., 21.,  28.,  8.,  16., 24.,  32.,  9.,  18., 27.,  36.,
      10., 20., 30.,  40.,  11., 22., 33.,  44.,  12., 24., 36.,  48.,
      13., 26., 39.,  52.,  14., 28., 42.,  56.,  15., 30., 45.,  60.,
      16., 32., 48.,  64.,  17., 34., 51.,  68.,  18., 36., 54.,  72.,
      19., 38., 57.,  76.,  20., 40., 60.,  80.,  21., 42., 63.,  84.,
      22., 44., 66.,  88.,  23., 46., 69.,  92.,  24., 48., 72.,  96.,
      25., 50., 75.,  100., 26., 52., 78.,  104., 27., 54., 81.,  108.,
      28., 56., 84.,  112., 29., 58., 87.,  116., 30., 60., 90.,  120.,
      31., 62., 93.,  124., 32., 64., 96.,  128., 33., 66., 99.,  132.,
      34., 68., 102., 136., 35., 70., 105., 140., 36., 72., 108., 144.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,   11.,  25.,  39.,  53.,   17.,  39.,  61.,
      83.,  23.,  53.,  83.,   113., 29.,  67.,  105.,  143., 35.,  81.,
      127., 173., 41.,  95.,   149., 203., 47.,  109.,  171., 233., 53.,
      123., 193., 263., 59.,   137., 215., 293., 65.,   151., 237., 323.,
      71.,  165., 259., 353.,  77.,  179., 281., 383.,  83.,  193., 303.,
      413., 89.,  207., 325.,  443., 95.,  221., 347.,  473., 101., 235.,
      369., 503., 107., 249.,  391., 533., 113., 263.,  413., 563., 119.,
      277., 435., 593., 125.,  291., 457., 623., 131.,  305., 479., 653.,
      137., 319., 501., 683.,  143., 333., 523., 713.,  149., 347., 545.,
      743., 155., 361., 567.,  773., 161., 375., 589.,  803., 167., 389.,
      611., 833., 173., 403.,  633., 863., 179., 417.,  655., 893., 185.,
      431., 677., 923., 191.,  445., 699., 953., 197.,  459., 721., 983.,
      203., 473., 743., 1013., 209., 487., 765., 1043., 215., 501., 787.,
      1073.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,   11.,  25.,  39.,  53.,   17.,  39.,  61.,
      83.,  23.,  53.,  83.,   113., 29.,  67.,  105.,  143., 35.,  81.,
      127., 173., 41.,  95.,   149., 203., 47.,  109.,  171., 233., 53.,
      123., 193., 263., 59.,   137., 215., 293., 65.,   151., 237., 323.,
      71.,  165., 259., 353.,  77.,  179., 281., 383.,  83.,  193., 303.,
      413., 89.,  207., 325.,  443., 95.,  221., 347.,  473., 101., 235.,
      369., 503., 107., 249.,  391., 533., 113., 263.,  413., 563., 119.,
      277., 435., 593., 125.,  291., 457., 623., 131.,  305., 479., 653.,
      137., 319., 501., 683.,  143., 333., 523., 713.,  149., 347., 545.,
      743., 155., 361., 567.,  773., 161., 375., 589.,  803., 167., 389.,
      611., 833., 173., 403.,  633., 863., 179., 417.,  655., 893., 185.,
      431., 677., 923., 191.,  445., 699., 953., 197.,  459., 721., 983.,
      203., 473., 743., 1013., 209., 487., 765., 1043., 215., 501., 787.,
      1073.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  70.,   174.,  278.,  382.,  110.,  278.,
      446.,  614.,  150.,  382.,  614.,  846.,  190.,  486.,  782.,  1078.,
      230.,  590.,  950.,  1310., 270.,  694.,  1118., 1542., 310.,  798.,
      1286., 1774., 350.,  902.,  1454., 2006., 390.,  1006., 1622., 2238.,
      430.,  1110., 1790., 2470., 470.,  1214., 1958., 2702., 510.,  1318.,
      2126., 2934., 550.,  1422., 2294., 3166., 590.,  1526., 2462., 3398.,
      630.,  1630., 2630., 3630., 670.,  1734., 2798., 3862., 710.,  1838.,
      2966., 4094., 750.,  1942., 3134., 4326., 790.,  2046., 3302., 4558.,
      830.,  2150., 3470., 4790., 870.,  2254., 3638., 5022., 910.,  2358.,
      3806., 5254., 950.,  2462., 3974., 5486., 990.,  2566., 4142., 5718.,
      1030., 2670., 4310., 5950., 1070., 2774., 4478., 6182., 1110., 2878.,
      4646., 6414., 1150., 2982., 4814., 6646., 1190., 3086., 4982., 6878.,
      1230., 3190., 5150., 7110., 1270., 3294., 5318., 7342., 1310., 3398.,
      5486., 7574., 1350., 3502., 5654., 7806., 1390., 3606., 5822., 8038.,
      1430., 3710., 5990., 8270.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  70.,   174.,  278.,  382.,  110.,  278.,
      446.,  614.,  150.,  382.,  614.,  846.,  190.,  486.,  782.,  1078.,
      230.,  590.,  950.,  1310., 270.,  694.,  1118., 1542., 310.,  798.,
      1286., 1774., 350.,  902.,  1454., 2006., 390.,  1006., 1622., 2238.,
      430.,  1110., 1790., 2470., 470.,  1214., 1958., 2702., 510.,  1318.,
      2126., 2934., 550.,  1422., 2294., 3166., 590.,  1526., 2462., 3398.,
      630.,  1630., 2630., 3630., 670.,  1734., 2798., 3862., 710.,  1838.,
      2966., 4094., 750.,  1942., 3134., 4326., 790.,  2046., 3302., 4558.,
      830.,  2150., 3470., 4790., 870.,  2254., 3638., 5022., 910.,  2358.,
      3806., 5254., 950.,  2462., 3974., 5486., 990.,  2566., 4142., 5718.,
      1030., 2670., 4310., 5950., 1070., 2774., 4478., 6182., 1110., 2878.,
      4646., 6414., 1150., 2982., 4814., 6646., 1190., 3086., 4982., 6878.,
      1230., 3190., 5150., 7110., 1270., 3294., 5318., 7342., 1310., 3398.,
      5486., 7574., 1350., 3502., 5654., 7806., 1390., 3606., 5822., 8038.,
      1430., 3710., 5990., 8270.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11., 17., 23., 29.,  35.,  41.,  47.,  53.,  59.,  65.,  71.,
      77., 83., 89., 95., 101., 107., 113., 119., 125., 131., 137., 143.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11., 17., 23., 29.,  35.,  41.,  47.,  53.,  59.,  65.,  71.,
      77., 83., 89., 95., 101., 107., 113., 119., 125., 131., 137., 143.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,  110., 150., 190., 230., 270., 310., 350., 390., 430., 470.,
      510., 550., 590., 630., 670., 710., 750., 790., 830., 870., 910., 950.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,  110., 150., 190., 230., 270., 310., 350., 390., 430., 470.,
      510., 550., 590., 630., 670., 710., 750., 790., 830., 870., 910., 950.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.,
      19., 38., 20., 40., 21., 42., 22., 44., 23., 46., 24., 48.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.,
      19., 38., 20., 40., 21., 42., 22., 44., 23., 46., 24., 48.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  11.,  25.,  17.,  39.,  23.,  53.,  29.,  67.,  35.,  81.,
      41.,  95.,  47.,  109., 53.,  123., 59.,  137., 65.,  151., 71.,  165.,
      77.,  179., 83.,  193., 89.,  207., 95.,  221., 101., 235., 107., 249.,
      113., 263., 119., 277., 125., 291., 131., 305., 137., 319., 143., 333.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  11.,  25.,  17.,  39.,  23.,  53.,  29.,  67.,  35.,  81.,
      41.,  95.,  47.,  109., 53.,  123., 59.,  137., 65.,  151., 71.,  165.,
      77.,  179., 83.,  193., 89.,  207., 95.,  221., 101., 235., 107., 249.,
      113., 263., 119., 277., 125., 291., 131., 305., 137., 319., 143., 333.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,   70.,  174.,  110., 278.,  150., 382.,  190., 486.,
      230., 590.,  270., 694.,  310., 798.,  350., 902.,  390., 1006.,
      430., 1110., 470., 1214., 510., 1318., 550., 1422., 590., 1526.,
      630., 1630., 670., 1734., 710., 1838., 750., 1942., 790., 2046.,
      830., 2150., 870., 2254., 910., 2358., 950., 2462.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,   70.,  174.,  110., 278.,  150., 382.,  190., 486.,
      230., 590.,  270., 694.,  310., 798.,  350., 902.,  390., 1006.,
      430., 1110., 470., 1214., 510., 1318., 550., 1422., 590., 1526.,
      630., 1630., 670., 1734., 710., 1838., 750., 1942., 790., 2046.,
      830., 2150., 870., 2254., 910., 2358., 950., 2462.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,
      12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28.,
      8.,  16., 24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22.,
      33., 44., 12., 24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56.,
      15., 30., 45., 60., 16., 32., 48., 64., 17., 34., 51., 68., 18., 36.,
      54., 72., 19., 38., 57., 76., 20., 40., 60., 80., 21., 42., 63., 84.,
      22., 44., 66., 88., 23., 46., 69., 92., 24., 48., 72., 96.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,
      12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28.,
      8.,  16., 24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22.,
      33., 44., 12., 24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56.,
      15., 30., 45., 60., 16., 32., 48., 64., 17., 34., 51., 68., 18., 36.,
      54., 72., 19., 38., 57., 76., 20., 40., 60., 80., 21., 42., 63., 84.,
      22., 44., 66., 88., 23., 46., 69., 92., 24., 48., 72., 96.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  11.,  25.,  39.,  53.,  17.,  39.,  61.,  83.,
      23.,  53.,  83.,  113., 29.,  67.,  105., 143., 35.,  81.,  127., 173.,
      41.,  95.,  149., 203., 47.,  109., 171., 233., 53.,  123., 193., 263.,
      59.,  137., 215., 293., 65.,  151., 237., 323., 71.,  165., 259., 353.,
      77.,  179., 281., 383., 83.,  193., 303., 413., 89.,  207., 325., 443.,
      95.,  221., 347., 473., 101., 235., 369., 503., 107., 249., 391., 533.,
      113., 263., 413., 563., 119., 277., 435., 593., 125., 291., 457., 623.,
      131., 305., 479., 653., 137., 319., 501., 683., 143., 333., 523., 713.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  11.,  25.,  39.,  53.,  17.,  39.,  61.,  83.,
      23.,  53.,  83.,  113., 29.,  67.,  105., 143., 35.,  81.,  127., 173.,
      41.,  95.,  149., 203., 47.,  109., 171., 233., 53.,  123., 193., 263.,
      59.,  137., 215., 293., 65.,  151., 237., 323., 71.,  165., 259., 353.,
      77.,  179., 281., 383., 83.,  193., 303., 413., 89.,  207., 325., 443.,
      95.,  221., 347., 473., 101., 235., 369., 503., 107., 249., 391., 533.,
      113., 263., 413., 563., 119., 277., 435., 593., 125., 291., 457., 623.,
      131., 305., 479., 653., 137., 319., 501., 683., 143., 333., 523., 713.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  70.,   174.,  278.,  382.,  110.,  278.,
      446.,  614.,  150.,  382.,  614.,  846.,  190.,  486.,  782.,  1078.,
      230.,  590.,  950.,  1310., 270.,  694.,  1118., 1542., 310.,  798.,
      1286., 1774., 350.,  902.,  1454., 2006., 390.,  1006., 1622., 2238.,
      430.,  1110., 1790., 2470., 470.,  1214., 1958., 2702., 510.,  1318.,
      2126., 2934., 550.,  1422., 2294., 3166., 590.,  1526., 2462., 3398.,
      630.,  1630., 2630., 3630., 670.,  1734., 2798., 3862., 710.,  1838.,
      2966., 4094., 750.,  1942., 3134., 4326., 790.,  2046., 3302., 4558.,
      830.,  2150., 3470., 4790., 870.,  2254., 3638., 5022., 910.,  2358.,
      3806., 5254., 950.,  2462., 3974., 5486.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  70.,   174.,  278.,  382.,  110.,  278.,
      446.,  614.,  150.,  382.,  614.,  846.,  190.,  486.,  782.,  1078.,
      230.,  590.,  950.,  1310., 270.,  694.,  1118., 1542., 310.,  798.,
      1286., 1774., 350.,  902.,  1454., 2006., 390.,  1006., 1622., 2238.,
      430.,  1110., 1790., 2470., 470.,  1214., 1958., 2702., 510.,  1318.,
      2126., 2934., 550.,  1422., 2294., 3166., 590.,  1526., 2462., 3398.,
      630.,  1630., 2630., 3630., 670.,  1734., 2798., 3862., 710.,  1838.,
      2966., 4094., 750.,  1942., 3134., 4326., 790.,  2046., 3302., 4558.,
      830.,  2150., 3470., 4790., 870.,  2254., 3638., 5022., 910.,  2358.,
      3806., 5254., 950.,  2462., 3974., 5486.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  29.,  35.,  41.,  47.,  53.,  59.,  65.,  71.,
      77.,  83.,  89.,  95.,  101., 107., 113., 119., 125., 131., 137., 143.,
      149., 155., 161., 167., 173., 179., 185., 191., 197., 203., 209., 215.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  29.,  35.,  41.,  47.,  53.,  59.,  65.,  71.,
      77.,  83.,  89.,  95.,  101., 107., 113., 119., 125., 131., 137., 143.,
      149., 155., 161., 167., 173., 179., 185., 191., 197., 203., 209., 215.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  190.,  230.,  270.,  310.,  350.,
      390.,  430.,  470.,  510.,  550.,  590.,  630.,  670.,  710.,
      750.,  790.,  830.,  870.,  910.,  950.,  990.,  1030., 1070.,
      1110., 1150., 1190., 1230., 1270., 1310., 1350., 1390., 1430.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  190.,  230.,  270.,  310.,  350.,
      390.,  430.,  470.,  510.,  550.,  590.,  630.,  670.,  710.,
      750.,  790.,  830.,  870.,  910.,  950.,  990.,  1030., 1070.,
      1110., 1150., 1190., 1230., 1270., 1310., 1350., 1390., 1430.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14., 8.,
      16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28., 15., 30.,
      16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42., 22., 44., 23.,
      46., 24., 48., 25., 50., 26., 52., 27., 54., 28., 56., 29., 58., 30., 60.,
      31., 62., 32., 64., 33., 66., 34., 68., 35., 70., 36., 72.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14., 8.,
      16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28., 15., 30.,
      16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42., 22., 44., 23.,
      46., 24., 48., 25., 50., 26., 52., 27., 54., 28., 56., 29., 58., 30., 60.,
      31., 62., 32., 64., 33., 66., 34., 68., 35., 70., 36., 72.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  11.,  25.,  17.,  39.,  23.,  53.,  29.,  67.,  35.,  81.,
      41.,  95.,  47.,  109., 53.,  123., 59.,  137., 65.,  151., 71.,  165.,
      77.,  179., 83.,  193., 89.,  207., 95.,  221., 101., 235., 107., 249.,
      113., 263., 119., 277., 125., 291., 131., 305., 137., 319., 143., 333.,
      149., 347., 155., 361., 161., 375., 167., 389., 173., 403., 179., 417.,
      185., 431., 191., 445., 197., 459., 203., 473., 209., 487., 215., 501.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  11.,  25.,  17.,  39.,  23.,  53.,  29.,  67.,  35.,  81.,
      41.,  95.,  47.,  109., 53.,  123., 59.,  137., 65.,  151., 71.,  165.,
      77.,  179., 83.,  193., 89.,  207., 95.,  221., 101., 235., 107., 249.,
      113., 263., 119., 277., 125., 291., 131., 305., 137., 319., 143., 333.,
      149., 347., 155., 361., 161., 375., 167., 389., 173., 403., 179., 417.,
      185., 431., 191., 445., 197., 459., 203., 473., 209., 487., 215., 501.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   70.,   174.,  110.,  278.,  150.,  382.,  190.,
      486.,  230.,  590.,  270.,  694.,  310.,  798.,  350.,  902.,
      390.,  1006., 430.,  1110., 470.,  1214., 510.,  1318., 550.,
      1422., 590.,  1526., 630.,  1630., 670.,  1734., 710.,  1838.,
      750.,  1942., 790.,  2046., 830.,  2150., 870.,  2254., 910.,
      2358., 950.,  2462., 990.,  2566., 1030., 2670., 1070., 2774.,
      1110., 2878., 1150., 2982., 1190., 3086., 1230., 3190., 1270.,
      3294., 1310., 3398., 1350., 3502., 1390., 3606., 1430., 3710.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   70.,   174.,  110.,  278.,  150.,  382.,  190.,
      486.,  230.,  590.,  270.,  694.,  310.,  798.,  350.,  902.,
      390.,  1006., 430.,  1110., 470.,  1214., 510.,  1318., 550.,
      1422., 590.,  1526., 630.,  1630., 670.,  1734., 710.,  1838.,
      750.,  1942., 790.,  2046., 830.,  2150., 870.,  2254., 910.,
      2358., 950.,  2462., 990.,  2566., 1030., 2670., 1070., 2774.,
      1110., 2878., 1150., 2982., 1190., 3086., 1230., 3190., 1270.,
      3294., 1310., 3398., 1350., 3502., 1390., 3606., 1430., 3710.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   2.,  4.,  6.,   8.,   3.,  6.,  9.,   12.,
      4.,  8.,  12.,  16.,  5.,  10., 15.,  20.,  6.,  12., 18.,  24.,
      7.,  14., 21.,  28.,  8.,  16., 24.,  32.,  9.,  18., 27.,  36.,
      10., 20., 30.,  40.,  11., 22., 33.,  44.,  12., 24., 36.,  48.,
      13., 26., 39.,  52.,  14., 28., 42.,  56.,  15., 30., 45.,  60.,
      16., 32., 48.,  64.,  17., 34., 51.,  68.,  18., 36., 54.,  72.,
      19., 38., 57.,  76.,  20., 40., 60.,  80.,  21., 42., 63.,  84.,
      22., 44., 66.,  88.,  23., 46., 69.,  92.,  24., 48., 72.,  96.,
      25., 50., 75.,  100., 26., 52., 78.,  104., 27., 54., 81.,  108.,
      28., 56., 84.,  112., 29., 58., 87.,  116., 30., 60., 90.,  120.,
      31., 62., 93.,  124., 32., 64., 96.,  128., 33., 66., 99.,  132.,
      34., 68., 102., 136., 35., 70., 105., 140., 36., 72., 108., 144.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   2.,  4.,  6.,   8.,   3.,  6.,  9.,   12.,
      4.,  8.,  12.,  16.,  5.,  10., 15.,  20.,  6.,  12., 18.,  24.,
      7.,  14., 21.,  28.,  8.,  16., 24.,  32.,  9.,  18., 27.,  36.,
      10., 20., 30.,  40.,  11., 22., 33.,  44.,  12., 24., 36.,  48.,
      13., 26., 39.,  52.,  14., 28., 42.,  56.,  15., 30., 45.,  60.,
      16., 32., 48.,  64.,  17., 34., 51.,  68.,  18., 36., 54.,  72.,
      19., 38., 57.,  76.,  20., 40., 60.,  80.,  21., 42., 63.,  84.,
      22., 44., 66.,  88.,  23., 46., 69.,  92.,  24., 48., 72.,  96.,
      25., 50., 75.,  100., 26., 52., 78.,  104., 27., 54., 81.,  108.,
      28., 56., 84.,  112., 29., 58., 87.,  116., 30., 60., 90.,  120.,
      31., 62., 93.,  124., 32., 64., 96.,  128., 33., 66., 99.,  132.,
      34., 68., 102., 136., 35., 70., 105., 140., 36., 72., 108., 144.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,   11.,  25.,  39.,  53.,   17.,  39.,  61.,
      83.,  23.,  53.,  83.,   113., 29.,  67.,  105.,  143., 35.,  81.,
      127., 173., 41.,  95.,   149., 203., 47.,  109.,  171., 233., 53.,
      123., 193., 263., 59.,   137., 215., 293., 65.,   151., 237., 323.,
      71.,  165., 259., 353.,  77.,  179., 281., 383.,  83.,  193., 303.,
      413., 89.,  207., 325.,  443., 95.,  221., 347.,  473., 101., 235.,
      369., 503., 107., 249.,  391., 533., 113., 263.,  413., 563., 119.,
      277., 435., 593., 125.,  291., 457., 623., 131.,  305., 479., 653.,
      137., 319., 501., 683.,  143., 333., 523., 713.,  149., 347., 545.,
      743., 155., 361., 567.,  773., 161., 375., 589.,  803., 167., 389.,
      611., 833., 173., 403.,  633., 863., 179., 417.,  655., 893., 185.,
      431., 677., 923., 191.,  445., 699., 953., 197.,  459., 721., 983.,
      203., 473., 743., 1013., 209., 487., 765., 1043., 215., 501., 787.,
      1073.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,   11.,  25.,  39.,  53.,   17.,  39.,  61.,
      83.,  23.,  53.,  83.,   113., 29.,  67.,  105.,  143., 35.,  81.,
      127., 173., 41.,  95.,   149., 203., 47.,  109.,  171., 233., 53.,
      123., 193., 263., 59.,   137., 215., 293., 65.,   151., 237., 323.,
      71.,  165., 259., 353.,  77.,  179., 281., 383.,  83.,  193., 303.,
      413., 89.,  207., 325.,  443., 95.,  221., 347.,  473., 101., 235.,
      369., 503., 107., 249.,  391., 533., 113., 263.,  413., 563., 119.,
      277., 435., 593., 125.,  291., 457., 623., 131.,  305., 479., 653.,
      137., 319., 501., 683.,  143., 333., 523., 713.,  149., 347., 545.,
      743., 155., 361., 567.,  773., 161., 375., 589.,  803., 167., 389.,
      611., 833., 173., 403.,  633., 863., 179., 417.,  655., 893., 185.,
      431., 677., 923., 191.,  445., 699., 953., 197.,  459., 721., 983.,
      203., 473., 743., 1013., 209., 487., 765., 1043., 215., 501., 787.,
      1073.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  70.,   174.,  278.,  382.,  110.,  278.,
      446.,  614.,  150.,  382.,  614.,  846.,  190.,  486.,  782.,  1078.,
      230.,  590.,  950.,  1310., 270.,  694.,  1118., 1542., 310.,  798.,
      1286., 1774., 350.,  902.,  1454., 2006., 390.,  1006., 1622., 2238.,
      430.,  1110., 1790., 2470., 470.,  1214., 1958., 2702., 510.,  1318.,
      2126., 2934., 550.,  1422., 2294., 3166., 590.,  1526., 2462., 3398.,
      630.,  1630., 2630., 3630., 670.,  1734., 2798., 3862., 710.,  1838.,
      2966., 4094., 750.,  1942., 3134., 4326., 790.,  2046., 3302., 4558.,
      830.,  2150., 3470., 4790., 870.,  2254., 3638., 5022., 910.,  2358.,
      3806., 5254., 950.,  2462., 3974., 5486., 990.,  2566., 4142., 5718.,
      1030., 2670., 4310., 5950., 1070., 2774., 4478., 6182., 1110., 2878.,
      4646., 6414., 1150., 2982., 4814., 6646., 1190., 3086., 4982., 6878.,
      1230., 3190., 5150., 7110., 1270., 3294., 5318., 7342., 1310., 3398.,
      5486., 7574., 1350., 3502., 5654., 7806., 1390., 3606., 5822., 8038.,
      1430., 3710., 5990., 8270.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  70.,   174.,  278.,  382.,  110.,  278.,
      446.,  614.,  150.,  382.,  614.,  846.,  190.,  486.,  782.,  1078.,
      230.,  590.,  950.,  1310., 270.,  694.,  1118., 1542., 310.,  798.,
      1286., 1774., 350.,  902.,  1454., 2006., 390.,  1006., 1622., 2238.,
      430.,  1110., 1790., 2470., 470.,  1214., 1958., 2702., 510.,  1318.,
      2126., 2934., 550.,  1422., 2294., 3166., 590.,  1526., 2462., 3398.,
      630.,  1630., 2630., 3630., 670.,  1734., 2798., 3862., 710.,  1838.,
      2966., 4094., 750.,  1942., 3134., 4326., 790.,  2046., 3302., 4558.,
      830.,  2150., 3470., 4790., 870.,  2254., 3638., 5022., 910.,  2358.,
      3806., 5254., 950.,  2462., 3974., 5486., 990.,  2566., 4142., 5718.,
      1030., 2670., 4310., 5950., 1070., 2774., 4478., 6182., 1110., 2878.,
      4646., 6414., 1150., 2982., 4814., 6646., 1190., 3086., 4982., 6878.,
      1230., 3190., 5150., 7110., 1270., 3294., 5318., 7342., 1310., 3398.,
      5486., 7574., 1350., 3502., 5654., 7806., 1390., 3606., 5822., 8038.,
      1430., 3710., 5990., 8270.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.,
      37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.,
      37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  29.,  35.,  41.,  47.,  53.,  59.,  65.,  71.,
      77.,  83.,  89.,  95.,  101., 107., 113., 119., 125., 131., 137., 143.,
      149., 155., 161., 167., 173., 179., 185., 191., 197., 203., 209., 215.,
      221., 227., 233., 239., 245., 251., 257., 263., 269., 275., 281., 287.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  29.,  35.,  41.,  47.,  53.,  59.,  65.,  71.,
      77.,  83.,  89.,  95.,  101., 107., 113., 119., 125., 131., 137., 143.,
      149., 155., 161., 167., 173., 179., 185., 191., 197., 203., 209., 215.,
      221., 227., 233., 239., 245., 251., 257., 263., 269., 275., 281., 287.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  190.,  230.,  270.,  310.,  350.,  390.,
      430.,  470.,  510.,  550.,  590.,  630.,  670.,  710.,  750.,  790.,
      830.,  870.,  910.,  950.,  990.,  1030., 1070., 1110., 1150., 1190.,
      1230., 1270., 1310., 1350., 1390., 1430., 1470., 1510., 1550., 1590.,
      1630., 1670., 1710., 1750., 1790., 1830., 1870., 1910.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  190.,  230.,  270.,  310.,  350.,  390.,
      430.,  470.,  510.,  550.,  590.,  630.,  670.,  710.,  750.,  790.,
      830.,  870.,  910.,  950.,  990.,  1030., 1070., 1110., 1150., 1190.,
      1230., 1270., 1310., 1350., 1390., 1430., 1470., 1510., 1550., 1590.,
      1630., 1670., 1710., 1750., 1790., 1830., 1870., 1910.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14.,
      8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28.,
      15., 30., 16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42.,
      22., 44., 23., 46., 24., 48., 25., 50., 26., 52., 27., 54., 28., 56.,
      29., 58., 30., 60., 31., 62., 32., 64., 33., 66., 34., 68., 35., 70.,
      36., 72., 37., 74., 38., 76., 39., 78., 40., 80., 41., 82., 42., 84.,
      43., 86., 44., 88., 45., 90., 46., 92., 47., 94., 48., 96.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14.,
      8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28.,
      15., 30., 16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42.,
      22., 44., 23., 46., 24., 48., 25., 50., 26., 52., 27., 54., 28., 56.,
      29., 58., 30., 60., 31., 62., 32., 64., 33., 66., 34., 68., 35., 70.,
      36., 72., 37., 74., 38., 76., 39., 78., 40., 80., 41., 82., 42., 84.,
      43., 86., 44., 88., 45., 90., 46., 92., 47., 94., 48., 96.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  11.,  25.,  17.,  39.,  23.,  53.,  29.,  67.,  35.,  81.,
      41.,  95.,  47.,  109., 53.,  123., 59.,  137., 65.,  151., 71.,  165.,
      77.,  179., 83.,  193., 89.,  207., 95.,  221., 101., 235., 107., 249.,
      113., 263., 119., 277., 125., 291., 131., 305., 137., 319., 143., 333.,
      149., 347., 155., 361., 161., 375., 167., 389., 173., 403., 179., 417.,
      185., 431., 191., 445., 197., 459., 203., 473., 209., 487., 215., 501.,
      221., 515., 227., 529., 233., 543., 239., 557., 245., 571., 251., 585.,
      257., 599., 263., 613., 269., 627., 275., 641., 281., 655., 287., 669.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  11.,  25.,  17.,  39.,  23.,  53.,  29.,  67.,  35.,  81.,
      41.,  95.,  47.,  109., 53.,  123., 59.,  137., 65.,  151., 71.,  165.,
      77.,  179., 83.,  193., 89.,  207., 95.,  221., 101., 235., 107., 249.,
      113., 263., 119., 277., 125., 291., 131., 305., 137., 319., 143., 333.,
      149., 347., 155., 361., 161., 375., 167., 389., 173., 403., 179., 417.,
      185., 431., 191., 445., 197., 459., 203., 473., 209., 487., 215., 501.,
      221., 515., 227., 529., 233., 543., 239., 557., 245., 571., 251., 585.,
      257., 599., 263., 613., 269., 627., 275., 641., 281., 655., 287., 669.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   70.,   174.,  110.,  278.,  150.,  382.,  190.,  486.,
      230.,  590.,  270.,  694.,  310.,  798.,  350.,  902.,  390.,  1006.,
      430.,  1110., 470.,  1214., 510.,  1318., 550.,  1422., 590.,  1526.,
      630.,  1630., 670.,  1734., 710.,  1838., 750.,  1942., 790.,  2046.,
      830.,  2150., 870.,  2254., 910.,  2358., 950.,  2462., 990.,  2566.,
      1030., 2670., 1070., 2774., 1110., 2878., 1150., 2982., 1190., 3086.,
      1230., 3190., 1270., 3294., 1310., 3398., 1350., 3502., 1390., 3606.,
      1430., 3710., 1470., 3814., 1510., 3918., 1550., 4022., 1590., 4126.,
      1630., 4230., 1670., 4334., 1710., 4438., 1750., 4542., 1790., 4646.,
      1830., 4750., 1870., 4854., 1910., 4958.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   70.,   174.,  110.,  278.,  150.,  382.,  190.,  486.,
      230.,  590.,  270.,  694.,  310.,  798.,  350.,  902.,  390.,  1006.,
      430.,  1110., 470.,  1214., 510.,  1318., 550.,  1422., 590.,  1526.,
      630.,  1630., 670.,  1734., 710.,  1838., 750.,  1942., 790.,  2046.,
      830.,  2150., 870.,  2254., 910.,  2358., 950.,  2462., 990.,  2566.,
      1030., 2670., 1070., 2774., 1110., 2878., 1150., 2982., 1190., 3086.,
      1230., 3190., 1270., 3294., 1310., 3398., 1350., 3502., 1390., 3606.,
      1430., 3710., 1470., 3814., 1510., 3918., 1550., 4022., 1590., 4126.,
      1630., 4230., 1670., 4334., 1710., 4438., 1750., 4542., 1790., 4646.,
      1830., 4750., 1870., 4854., 1910., 4958.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   2.,  4.,  6.,   8.,   3.,  6.,  9.,   12.,
      4.,  8.,  12.,  16.,  5.,  10., 15.,  20.,  6.,  12., 18.,  24.,
      7.,  14., 21.,  28.,  8.,  16., 24.,  32.,  9.,  18., 27.,  36.,
      10., 20., 30.,  40.,  11., 22., 33.,  44.,  12., 24., 36.,  48.,
      13., 26., 39.,  52.,  14., 28., 42.,  56.,  15., 30., 45.,  60.,
      16., 32., 48.,  64.,  17., 34., 51.,  68.,  18., 36., 54.,  72.,
      19., 38., 57.,  76.,  20., 40., 60.,  80.,  21., 42., 63.,  84.,
      22., 44., 66.,  88.,  23., 46., 69.,  92.,  24., 48., 72.,  96.,
      25., 50., 75.,  100., 26., 52., 78.,  104., 27., 54., 81.,  108.,
      28., 56., 84.,  112., 29., 58., 87.,  116., 30., 60., 90.,  120.,
      31., 62., 93.,  124., 32., 64., 96.,  128., 33., 66., 99.,  132.,
      34., 68., 102., 136., 35., 70., 105., 140., 36., 72., 108., 144.,
      37., 74., 111., 148., 38., 76., 114., 152., 39., 78., 117., 156.,
      40., 80., 120., 160., 41., 82., 123., 164., 42., 84., 126., 168.,
      43., 86., 129., 172., 44., 88., 132., 176., 45., 90., 135., 180.,
      46., 92., 138., 184., 47., 94., 141., 188., 48., 96., 144., 192.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   2.,  4.,  6.,   8.,   3.,  6.,  9.,   12.,
      4.,  8.,  12.,  16.,  5.,  10., 15.,  20.,  6.,  12., 18.,  24.,
      7.,  14., 21.,  28.,  8.,  16., 24.,  32.,  9.,  18., 27.,  36.,
      10., 20., 30.,  40.,  11., 22., 33.,  44.,  12., 24., 36.,  48.,
      13., 26., 39.,  52.,  14., 28., 42.,  56.,  15., 30., 45.,  60.,
      16., 32., 48.,  64.,  17., 34., 51.,  68.,  18., 36., 54.,  72.,
      19., 38., 57.,  76.,  20., 40., 60.,  80.,  21., 42., 63.,  84.,
      22., 44., 66.,  88.,  23., 46., 69.,  92.,  24., 48., 72.,  96.,
      25., 50., 75.,  100., 26., 52., 78.,  104., 27., 54., 81.,  108.,
      28., 56., 84.,  112., 29., 58., 87.,  116., 30., 60., 90.,  120.,
      31., 62., 93.,  124., 32., 64., 96.,  128., 33., 66., 99.,  132.,
      34., 68., 102., 136., 35., 70., 105., 140., 36., 72., 108., 144.,
      37., 74., 111., 148., 38., 76., 114., 152., 39., 78., 117., 156.,
      40., 80., 120., 160., 41., 82., 123., 164., 42., 84., 126., 168.,
      43., 86., 129., 172., 44., 88., 132., 176., 45., 90., 135., 180.,
      46., 92., 138., 184., 47., 94., 141., 188., 48., 96., 144., 192.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    11.,   17.,   23.,   11.,  25.,   39.,   53.,   17.,  39.,
      61.,   83.,   23.,   53.,   83.,  113.,  29.,   67.,   105., 143.,
      35.,   81.,   127.,  173.,  41.,  95.,   149.,  203.,  47.,  109.,
      171.,  233.,  53.,   123.,  193., 263.,  59.,   137.,  215., 293.,
      65.,   151.,  237.,  323.,  71.,  165.,  259.,  353.,  77.,  179.,
      281.,  383.,  83.,   193.,  303., 413.,  89.,   207.,  325., 443.,
      95.,   221.,  347.,  473.,  101., 235.,  369.,  503.,  107., 249.,
      391.,  533.,  113.,  263.,  413., 563.,  119.,  277.,  435., 593.,
      125.,  291.,  457.,  623.,  131., 305.,  479.,  653.,  137., 319.,
      501.,  683.,  143.,  333.,  523., 713.,  149.,  347.,  545., 743.,
      155.,  361.,  567.,  773.,  161., 375.,  589.,  803.,  167., 389.,
      611.,  833.,  173.,  403.,  633., 863.,  179.,  417.,  655., 893.,
      185.,  431.,  677.,  923.,  191., 445.,  699.,  953.,  197., 459.,
      721.,  983.,  203.,  473.,  743., 1013., 209.,  487.,  765., 1043.,
      215.,  501.,  787.,  1073., 221., 515.,  809.,  1103., 227., 529.,
      831.,  1133., 233.,  543.,  853., 1163., 239.,  557.,  875., 1193.,
      245.,  571.,  897.,  1223., 251., 585.,  919.,  1253., 257., 599.,
      941.,  1283., 263.,  613.,  963., 1313., 269.,  627.,  985., 1343.,
      275.,  641.,  1007., 1373., 281., 655.,  1029., 1403., 287., 669.,
      1051., 1433.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    11.,   17.,   23.,   11.,  25.,   39.,   53.,   17.,  39.,
      61.,   83.,   23.,   53.,   83.,  113.,  29.,   67.,   105., 143.,
      35.,   81.,   127.,  173.,  41.,  95.,   149.,  203.,  47.,  109.,
      171.,  233.,  53.,   123.,  193., 263.,  59.,   137.,  215., 293.,
      65.,   151.,  237.,  323.,  71.,  165.,  259.,  353.,  77.,  179.,
      281.,  383.,  83.,   193.,  303., 413.,  89.,   207.,  325., 443.,
      95.,   221.,  347.,  473.,  101., 235.,  369.,  503.,  107., 249.,
      391.,  533.,  113.,  263.,  413., 563.,  119.,  277.,  435., 593.,
      125.,  291.,  457.,  623.,  131., 305.,  479.,  653.,  137., 319.,
      501.,  683.,  143.,  333.,  523., 713.,  149.,  347.,  545., 743.,
      155.,  361.,  567.,  773.,  161., 375.,  589.,  803.,  167., 389.,
      611.,  833.,  173.,  403.,  633., 863.,  179.,  417.,  655., 893.,
      185.,  431.,  677.,  923.,  191., 445.,  699.,  953.,  197., 459.,
      721.,  983.,  203.,  473.,  743., 1013., 209.,  487.,  765., 1043.,
      215.,  501.,  787.,  1073., 221., 515.,  809.,  1103., 227., 529.,
      831.,  1133., 233.,  543.,  853., 1163., 239.,  557.,  875., 1193.,
      245.,  571.,  897.,  1223., 251., 585.,  919.,  1253., 257., 599.,
      941.,  1283., 263.,  613.,  963., 1313., 269.,  627.,  985., 1343.,
      275.,  641.,  1007., 1373., 281., 655.,  1029., 1403., 287., 669.,
      1051., 1433.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, SAME3x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,   70.,   174.,   278.,  382.,   110.,  278.,
      446.,  614.,  150.,  382.,   614.,  846.,   190.,  486.,   782.,  1078.,
      230.,  590.,  950.,  1310.,  270.,  694.,   1118., 1542.,  310.,  798.,
      1286., 1774., 350.,  902.,   1454., 2006.,  390.,  1006.,  1622., 2238.,
      430.,  1110., 1790., 2470.,  470.,  1214.,  1958., 2702.,  510.,  1318.,
      2126., 2934., 550.,  1422.,  2294., 3166.,  590.,  1526.,  2462., 3398.,
      630.,  1630., 2630., 3630.,  670.,  1734.,  2798., 3862.,  710.,  1838.,
      2966., 4094., 750.,  1942.,  3134., 4326.,  790.,  2046.,  3302., 4558.,
      830.,  2150., 3470., 4790.,  870.,  2254.,  3638., 5022.,  910.,  2358.,
      3806., 5254., 950.,  2462.,  3974., 5486.,  990.,  2566.,  4142., 5718.,
      1030., 2670., 4310., 5950.,  1070., 2774.,  4478., 6182.,  1110., 2878.,
      4646., 6414., 1150., 2982.,  4814., 6646.,  1190., 3086.,  4982., 6878.,
      1230., 3190., 5150., 7110.,  1270., 3294.,  5318., 7342.,  1310., 3398.,
      5486., 7574., 1350., 3502.,  5654., 7806.,  1390., 3606.,  5822., 8038.,
      1430., 3710., 5990., 8270.,  1470., 3814.,  6158., 8502.,  1510., 3918.,
      6326., 8734., 1550., 4022.,  6494., 8966.,  1590., 4126.,  6662., 9198.,
      1630., 4230., 6830., 9430.,  1670., 4334.,  6998., 9662.,  1710., 4438.,
      7166., 9894., 1750., 4542.,  7334., 10126., 1790., 4646.,  7502., 10358.,
      1830., 4750., 7670., 10590., 1870., 4854.,  7838., 10822., 1910., 4958.,
      8006., 11054.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow1Stride1, VALID3x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,   70.,   174.,   278.,  382.,   110.,  278.,
      446.,  614.,  150.,  382.,   614.,  846.,   190.,  486.,   782.,  1078.,
      230.,  590.,  950.,  1310.,  270.,  694.,   1118., 1542.,  310.,  798.,
      1286., 1774., 350.,  902.,   1454., 2006.,  390.,  1006.,  1622., 2238.,
      430.,  1110., 1790., 2470.,  470.,  1214.,  1958., 2702.,  510.,  1318.,
      2126., 2934., 550.,  1422.,  2294., 3166.,  590.,  1526.,  2462., 3398.,
      630.,  1630., 2630., 3630.,  670.,  1734.,  2798., 3862.,  710.,  1838.,
      2966., 4094., 750.,  1942.,  3134., 4326.,  790.,  2046.,  3302., 4558.,
      830.,  2150., 3470., 4790.,  870.,  2254.,  3638., 5022.,  910.,  2358.,
      3806., 5254., 950.,  2462.,  3974., 5486.,  990.,  2566.,  4142., 5718.,
      1030., 2670., 4310., 5950.,  1070., 2774.,  4478., 6182.,  1110., 2878.,
      4646., 6414., 1150., 2982.,  4814., 6646.,  1190., 3086.,  4982., 6878.,
      1230., 3190., 5150., 7110.,  1270., 3294.,  5318., 7342.,  1310., 3398.,
      5486., 7574., 1350., 3502.,  5654., 7806.,  1390., 3606.,  5822., 8038.,
      1430., 3710., 5990., 8270.,  1470., 3814.,  6158., 8502.,  1510., 3918.,
      6326., 8734., 1550., 4022.,  6494., 8966.,  1590., 4126.,  6662., 9198.,
      1630., 4230., 6830., 9430.,  1670., 4334.,  6998., 9662.,  1710., 4438.,
      7166., 9894., 1750., 4542.,  7334., 10126., 1790., 4646.,  7502., 10358.,
      1830., 4750., 7670., 10590., 1870., 4854.,  7838., 10822., 1910., 4958.,
      8006., 11054.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}